Razkrivamo motor: Poglobljen vpogled v algoritme za ujemanje vzorcev v Pythonovih regexih

Regularni izrazi, ali regexi, so temelj sodobnega razvoja programske opreme. Za nešteto programerjev po vsem svetu so nepogrešljivo orodje za obdelavo besedil, validacijo podatkov in razčlenjevanje dnevnikov. Uporabljamo jih za iskanje, zamenjavo in izdvajanje informacij z natančnostjo, ki je s preprostimi niznimi metodami ne moremo doseči. Vendar pa za mnoge regex motor ostaja črna skrinjica – čarobno orodje, ki sprejme kriptičen vzorec in niz ter nekako vrne rezultat. Pomanjkanje razumevanja lahko vodi do neučinkovite kode in v nekaterih primerih do katastrofalnih težav z zmogljivostjo.

Ta članek sname zastor s Pythonovega re modula. Podali se bomo v jedro njegovega motorja za ujemanje vzorcev in raziskali temeljne algoritme, ki ga poganjajo. Z razumevanjem, kako motor deluje, boste lahko pisali učinkovitejše, bolj robustne in predvidljive regularne izraze, s čimer boste svojo uporabo tega zmogljivega orodja spremenili iz ugibanja v znanost.

Jedro regularnih izrazov: Kaj je regex motor?

V svojem bistvu je regex motor kos programske opreme, ki sprejme dva vhoda: vzorec (regex) in vhodni niz. Njegovo delo je ugotoviti, ali je vzorec mogoče najti v nizu. Če je, motor javi uspešno ujemanje in pogosto zagotovi podrobnosti, kot so začetni in končni položaji ujemajočega se besedila ter morebitne zajete skupine.

Čeprav je cilj preprost, njegova implementacija ni. Regex motorji so običajno zgrajeni na enem od dveh temeljnih algoritmičnih pristopov, ki izhajata iz teoretične računalniške znanosti, zlasti iz teorije končnih avtomatov.

• SmeriBesedila (na osnovi DFA): Ti motorji, ki temeljijo na determinističnih končnih avtomatih (DFA), obdelujejo vhodni niz znak po znak. Izjemno hitri so in zagotavljajo predvidljivo, linearno časovno zmogljivost. Nikoli jim ni treba izvajati povratnega sledenja ali ponovno ocenjevati delov niza. Vendar pa ta hitrost pride na račun funkcij; DFA motorji ne morejo podpirati naprednih konstruktov, kot so povratne reference ali leni kvantifikatorji. Orodja, kot sta `grep` in `lex`, pogosto uporabljajo motorje na osnovi DFA.
• SmeriRegex (na osnovi NFA): Ti motorji, ki temeljijo na nedeterminističnih končnih avtomatih (NFA), so vodeni z vzorcem. Premikajo se skozi vzorec in poskušajo njegove komponente ujemati z nizom. Ta pristop je bolj prilagodljiv in zmogljiv, saj podpira širok nabor funkcij, vključno z zajemalnimi skupinami, povratnimi referencami in pogledi naprej/nazaj. Večina sodobnih programskih jezikov, vključno s Pythonom, Perlom, Javo in JavaScriptom, uporablja motorje na osnovi NFA.

Pythonov re modul uporablja tradicionalni NFA motor, ki se zanaša na ključni mehanizem, imenovan povratno sledenje (backtracking). Ta izbira zasnove je ključ do njegove moči in potencialnih pasti v zmogljivosti.

Zgodba o dveh avtomatih: NFA proti DFA

Če želimo resnično razumeti, kako deluje Pythonov regex motor, je koristno primerjati oba dominantna modela. Pomislite nanju kot na dve različni strategiji za navigacijo po labirintu (vhodni niz) z zemljevidom (regex vzorec).

Deterministični končni avtomati (DFA): Neomajna pot

Predstavljajte si stroj, ki bere vhodni niz znak po znak. V katerem koli trenutku je v točno enem stanju. Za vsak znak, ki ga prebere, obstaja samo en možen naslednji stanje. Ni dvoumnosti, ni izbire, ni vračanja nazaj. To je DFA.

• Kako deluje: DFA motor zgradi stroje za stanja, kjer vsako stanje predstavlja sklop možnih položajev v regex vzorcu. Obdeluje vhodni niz od leve proti desni. Po branju vsakega znaka posodobi svoje trenutno stanje na podlagi deterministične tabele prehodov. Če doseže konec niza v "sprejemajočem" stanju, je ujemanje uspešno.
• Prednosti:
  • Hitrost: DFA obdelujejo nize v linearnem času, O(n), kjer je n dolžina niza. Zapletenost vzorca ne vpliva na čas iskanja.
  • Predvidljivost: Zmogljivost je dosledna in nikoli ne upade v eksponentni čas.
• Slabosti:
  • Omejene funkcije: Zaradi narave determinizma DFA je nemogoče implementirati funkcije, ki zahtevajo pomnjenje prejšnjega ujemanja, kot so povratne reference (npr. (\w+)\s+\1). V povprečju leni kvantifikatorji in pogledi naprej/nazaj tudi običajno niso podprti.
  • Eksplozija stanj: Kompilacija zapletenega vzorca v DFA lahko včasih povzroči eksponentno veliko število stanj, kar porabi znatno količino pomnilnika.

Nedeterministični končni avtomati (NFA): Pot možnosti

Zdaj si predstavljajte drugačen stroj. Ko prebere znak, ima lahko več možnih naslednjih stanj. Kot bi se stroj lahko kloniral, da bi hkrati raziskoval vse poti. NFA motor simulira ta proces, običajno tako, da poskuša eno pot naenkrat in ob neuspehu izvede povratno sledenje. To je NFA.

• Kako deluje: NFA motor se sprehaja po regex vzorcu in za vsak žeton v vzorcu ga poskuša ujemati s trenutnim položajem v nizu. Če žeton dopušča več možnosti (kot je alternativa `|` ali kvantifikator `*`), motor izbere eno možnost in druge shrani za pozneje. Če izbrana pot ne povzroči popolnega ujemanja, motor izvede povratno sledenje do zadnje točke izbire in poskusi naslednjo alternativo.
• Prednosti:
  • Zmogljive funkcije: Ta model podpira bogat nabor funkcij, vključno z zajemalnimi skupinami, povratnimi referencami, pogledi naprej, pogledi nazaj ter tako pohlepnimi kot lenimi kvantifikatorji.
  • Izraznost: NFA motorji lahko obravnavajo širši spekter zapletenih vzorcev.
• Slabosti:
  • Variabilnost zmogljivosti: V najboljšem primeru so NFA motorji hitri. V najslabšem primeru lahko mehanizem povratnega sledenja privede do eksponentne časovne kompleksnosti, O(2^n), kar je pojav, znan kot "katastrofalno povratno sledenje".

Srce Pythonovega modula `re`: NFA motor z povratnim sledenjem

Pythonov regex motor je klasičen primer NFA z povratnim sledenjem. Razumevanje tega mehanizma je najpomembnejši koncept za pisanje učinkovitih regularnih izrazov v Pythonu. Poglejmo si analogijo: predstavljajte si, da ste v labirintu in imate navodila (vzorec). Sledite eni poti. Če naletite na slepo ulico, se vrnete do zadnjega križišča, kjer ste imeli izbiro, in poskusite drugo pot. Ta proces "prehoditi nazaj in poskusiti znova" je povratno sledenje.

Korak za korakom primer povratnega sledenja

Poglejmo, kako motor obravnava na videz preprost vzorec. Ta primer prikazuje temeljni koncept pohlepnega ujemanja in povratnega sledenja.

• Vzorec: a.*b
• Niz: axbyc_bzd

Cilj je najti podniz, ki se začne z 'a', konča z 'b', in ima med njima karkoli.

1. Motor začne pri prvem znaku niza. Prvi del vzorca je a. Ujema se z 'a' na začetku niza. Položaj motorja je zdaj za 'a'.
2. Sledi .*. Kvantifikator * je privzeto pohlepen. To je ključna točka. Pohlepni kvantifikator bo ujel čim več znakov. Tako .* porabi celoten preostanek niza: `xbyc_bzd`.
3. Motor je zdaj dosegel konec dela .* vzorca in poskuša ujemati naslednji žeton: b. Vendar je že na koncu niza. Ni več znakov za ujemanje. Ujemaje se na tem mestu ne uspe.
4. POVRATNO SLEDI! Motor mora ponovno razmisliti o svoji zadnji izbiri. Zadnja večja izbira je bila, koliko znakov naj pohlepni .* porabi. Bil je preveč pohlepen. Torej, izvede povratno sledenje: .* vrne en znak nazaj.
   • Niz, ki ga je porabil .*, je zdaj `xbyc_bz`.
   • Vrnjeni znak je `d`.
   • Motor poskuša ujemati b z `d`. To ne uspe.
5. PONOVNO POVRAČNO SLEDI! .* vrne še en znak nazaj.
   • Niz, ki ga je porabil .*, je zdaj `xbyc_b`.
   • Vrnjeni znak je `z`.
   • Motor poskuša ujemati b z `z`. To ne uspe.
6. PONOVNO POVRAČNO SLEDI! .* vrne še en znak nazaj.
   • Niz, ki ga je porabil .*, je zdaj `xbyc_`.
   • Vrnjeni znak je `b`.
   • Motor poskuša ujemati b z `b`. Uspeh!
7. Celoten vzorec a.*b je zdaj ujemajoč. Končno ujemanje je axbyc_b.

Ta preprost primer prikazuje naravo poskusov in napak motorja. Za zapletene vzorce in dolge nize se ta proces porabe in vračanja lahko zgodi tisočkrat ali celo milijonkrat, kar vodi do resnih težav z zmogljivostjo.

Nevarnost povratnega sledenja: Katastrofalno povratno sledenje

Katastrofalno povratno sledenje je specifičen, najslabši scenarij, pri katerem se število permutacij, ki jih mora motor preizkusiti, eksponentno poveča. To lahko povzroči, da se program ustavi in porabi 100% jedra CPU-ja za sekunde, minute ali celo dlje, kar učinkovito ustvari ranljivost za zavrnitev storitve z regularnimi izrazi (ReDoS).

Ta situacija običajno nastane zaradi vzorca, ki ima gnezdene kvantifikatorje s prekrivajočimi se nizi znakov, ki se nanašajo na niz, ki skoraj, a ne povsem, ustreza.

Razmislite o klasičnem patološkem primeru:

• Vzorec: (a+)+z
• Niz: aaaaaaaaaaaaaaaaaaaaaaaaaz (25 'a' in en 'z')

To se bo hitro ujemalo. Zunanji `(a+)+` bo ujel vseh 'a' v enem zamahu, nato pa bo `z` ujel 'z'.

Zdaj pa razmislite o tem nizu:

• Niz: aaaaaaaaaaaaaaaaaaaaaaaaab (25 'a' in en 'b')

1. Notranji a+ lahko ujame eno ali več 'a'.
2. Zunanji kvantifikator + pravi, da se lahko skupina (a+) ponovi enkrat ali večkrat.
3. Za ujemanje niza 25 'a' ima motor veliko, veliko načinov, kako ga razdeliti. Na primer:
   • Zunanja skupina se ujema enkrat, pri čemer notranji a+ ujame vseh 25 'a'.
   • Zunanja skupina se ujema dvakrat, pri čemer notranji a+ ujame 1 'a', nato pa 24 'a'.
   • Ali 2 'a', nato pa 23 'a'.
   • Ali se zunanja skupina ujema 25-krat, pri čemer notranji a+ vsakič ujame en 'a'.

Motor bo najprej poskusil najbolj pohlepno ujemanje: zunanja skupina se ujema enkrat, notranji `a+` pa porabi vseh 25 'a'. Nato poskuša ujemati `z` z `b`. Ne uspe. Torej, izvede povratno sledenje. Poskusi naslednjo možno delitev 'a'. In naslednjo. In naslednjo. Število načinov za delitev niza 'a' je eksponentno. Motor je prisiljen poskusiti vsakega posameznega, preden lahko zaključi, da se niz ne ujema. Z le 25 'a' lahko to traja milijone korakov.

Kako prepoznati in preprečiti katastrofalno povratno sledenje

Ključ do pisanja učinkovitih regexov je v vodenju motorja in zmanjšanju števila korakov povratnega sledenja, ki jih mora izvesti.

1. Izogibajte se gnezditvi kvantifikatorjev s prekrivajočimi se vzorci
Glavni vzrok katastrofalnega povratnega sledenja je vzorec, kot je (a*)*, (a+|b+)* ali (a+)+. Preverite svoje vzorce glede te strukture. Pogosto jo je mogoče poenostaviti. Na primer, (a+)+ je funkcionalno enakovredno veliko varnejšemu a+. Vzorec (a|b)+ je veliko varnejši kot (a+|b+)*.

2. Naredite pohlepne kvantifikatorje leni (ne-pohlepni)
Privzeto so kvantifikatorji (`*`, `+`, `{m,n}`) pohlepni. Lahko jih naredite leni z dodajanjem `?`. Leni kvantifikator ujame čim manj znakov, le razširi svoje ujemanje, če je to potrebno, da bi ostali del vzorca uspel.

• Pohlepen: <h1>.*</h1> na nizu "<h1>Naslov 1</h1> <h1>Naslov 2</h1>" bo ujel celoten niz od prvega <h1> do zadnjega </h1>.
• Leni: <h1>.*?</h1> na istem nizu bo najprej ujel "<h1>Naslov 1</h1>". To je pogosto želeno obnašanje in lahko znatno zmanjša povratno sledenje.

3. Uporabite posesivne kvantifikatorje in atomačne skupine (kadar je mogoče)
Nekateri napredni regex motorji ponujajo funkcije, ki izrecno prepovedujejo povratno sledenje. Čeprav Pythonov standardni modul `re` teh ne podpira, ga odličen modul `regex` tretje stranke podpira, in je vredno orodje za zapleteno ujemanje vzorcev.

• Posesivni kvantifikatorji (`*+`, `++`, `?+`): Ti so kot pohlepni kvantifikatorji, vendar ko enkrat ujamejo, nikoli ne vrnejo nobenih znakov. Motorju ni dovoljeno izvajati povratnega sledenja vanje. Vzorec (a++)+z bi skoraj takoj neuspel na našem problematičnem nizu, ker bi `a++` porabil vse 'a', nato pa ne bi dovolil povratnega sledenja, kar bi povzročilo takojšen neuspeh celotnega ujemanja.
• Atomačne skupine `(?>...)`:** Atomačna skupina je nekazotvarna skupina, ki po izhodu iz nje zavrže vsa povratna sledenja znotraj nje. Motor ne more izvajati povratnega sledenja v skupino, da bi poskušal različne permutacije. `(?>a+)z` se obnaša podobno kot `a++z`.

import re

# Analizirajmo vzorec 'a(b|c)+d'
re.compile('a(b|c)+d', re.DEBUG)

LITERAL 97          # Ujemaj znak 'a'
MAX_REPEAT 1 65535  # Začni kvantifikator: ujemaj naslednjo skupino 1 do neomejenokrat
  SUBPATTERN 1 0 0    # Začni zajemalno skupino 1
    BRANCH            # Začni alternacijo (znak '|')
      LITERAL 98      # V prvi veji ujemaj 'b'
    OR
      LITERAL 99      # V drugi veji ujemaj 'c'
    MARK 1            # Končaj zajemalno skupino 1
LITERAL 100         # Ujemaj znak 'd'
SUCCESS             # Celoten vzorec se je uspešno ujemal